package com.neusoft.hifly.commons.validator;

import org.apache.commons.lang3.StringUtils;

import com.neusoft.hifly.core.log.Log;

/**
 * Title: 核心类库
 * <p>
 * Description: 比较校验器
 * <p>
 * 例如：
 * <p>
 * compareValidator="desID:pubTime,operateor:>=,onerror:失效日期不能早于发布日期"
 * <p>
 * 其中：
 * <p>
 * desID：待比较控件的id
 * <p>
 * operateor：比较类型（<、>、=、<=、>=），分别对应的转译字符为（&lt;、&gt;、=、&lt;=、&gt=）
 * <p>
 * onerror：错误提示信息
 * <p>
 * Copyright: 2019
 * <p>
 * Company: 东软汉枫
 *
 * @author lh_neu
 * @version 1.0.0
 */
public final class CompareValidator {
	public static boolean isTest; // 是否测试状态，是否输入log

	/**
	 * 单个控件校验器
	 *
	 * @param val
	 *            待比较者
	 * @param desVal
	 *            被校验者
	 * @param operateor
	 *            比较类型（<、>、=、<=、>=），分别对应的转译字符为（&lt;、&gt;、=、&lt;=、&gt=）
	 * @return 是否成功
	 */
	public static boolean validate(final Object val, final Object desVal, final String operateor) {
		if (CompareValidator.isTest) {
			Log.debug("CompareValidator : [ val: {} , desVal: {} , operateor: {}",
					new Object[] { val, desVal, operateor });
		}
		// 为空时，返回正确信息
		if ((val == null) || (desVal == null) || StringUtils.isEmpty(operateor)) {
			return true;
		}
		if ((val instanceof Integer) && (desVal instanceof Integer)) {
			// 两者均为数值型时
			final Integer valInt = (Integer) val;
			final Integer desValInt = (Integer) desVal;
			return CompareValidator.validateInt(valInt, desValInt, operateor);
		} else if ((val instanceof String) && (desVal instanceof String)) {
			// 两者均为字符型时
			final String valStr = (String) val;
			final String desValStr = (String) desVal;

			// 判断两个字符能否转变为数字，若能转换，则采用数值型校验
			if (StringUtils.isNumeric(valStr) && StringUtils.isNumeric(desValStr)) {
				return CompareValidator.validateInt(Integer.parseInt(valStr), Integer.parseInt(desValStr), operateor);
			} else {
				return CompareValidator.validateStr(valStr, desValStr, operateor);
			}
		} else if ((val instanceof Integer) && (desVal instanceof String)) {
			// 数值型与字符型比较时
			final Integer valInt = (Integer) val;
			final String desValStr = (String) desVal;
			// 判断字符能否转变为数字，若能转换，则采用数值型校验
			if (StringUtils.isNumeric(desValStr)) {
				return CompareValidator.validateInt(valInt.intValue(), Integer.parseInt(desValStr), operateor);
			} else {
				return CompareValidator.validateStr(valInt.intValue() + "", desValStr, operateor);
			}
		} else if ((val instanceof String) && (desVal instanceof Integer)) {
			// 字符型与数值型比较时
			final String valStr = (String) val;
			final Integer desValInt = (Integer) desVal;
			// 判断字符能否转变为数字，若能转换，则采用数值型校验
			if (StringUtils.isNumeric(valStr)) {
				return CompareValidator.validateInt(Integer.parseInt(valStr), desValInt.intValue(), operateor);
			} else {
				return CompareValidator.validateStr(valStr, desValInt.intValue() + "", operateor);
			}
		}
		return false;
	}

	/**
	 * 校验数值型
	 *
	 * @param val
	 *            待比较者
	 * @param desVal
	 *            被校验者
	 * @param operateor
	 *            比较类型（<、>、=、<=、>=），分别对应的转译字符为（&lt;、&gt;、=、&lt;=、&gt=）
	 * @return 是否正确
	 */
	private static boolean validateInt(final int val, final int desVal, final String operateor) {
		if ("<".equals(operateor) || "&lt;".equals(operateor)) {
			// 小于
			return val < desVal;
		} else if (">".equals(operateor) || "&gt;".equals(operateor)) {
			// 大于
			return val > desVal;
		} else if ("=".equals(operateor) || "&gt;".equals(operateor)) {
			// 等于
			return val == desVal;
		} else if ("<=".equals(operateor) || "&lt;=".equals(operateor)) {
			// 小于等于
			return val <= desVal;
		} else if (">=".equals(operateor) || "&gt=".equals(operateor)) {
			// 大于等于
			return val >= desVal;
		} else {
			return true;
		}
	}

	/**
	 * 校验字符型
	 *
	 * @param val
	 *            待比较者
	 * @param desVal
	 *            被校验者
	 * @param operateor
	 *            比较类型（<、>、=、<=、>=），分别对应的转译字符为（&lt;、&gt;、=、&lt;=、&gt=）
	 * @return 是否正确
	 */
	private static boolean validateStr(final String val, final String desVal, final String operateor) {
		if (StringUtils.isEmpty(val) || StringUtils.isEmpty(desVal)) {
			return true;
		} else if ("<".equals(operateor) || "&lt;".equals(operateor)) {
			// 小于
			return val.compareTo(desVal) < 0;
		} else if (">".equals(operateor) || "&gt;".equals(operateor)) {
			// 大于
			return val.compareTo(desVal) > 0;
		} else if ("=".equals(operateor) || "&gt;".equals(operateor)) {
			// 等于
			return val.equals(val);
		} else if ("<=".equals(operateor) || "&lt;=".equals(operateor)) {
			// 小于等于
			return (val.compareTo(desVal) < 0) || val.equals(desVal);
		} else if (">=".equals(operateor) || "&gt=".equals(operateor)) {
			// 大于等于
			return (val.compareTo(desVal) > 0) || val.equals(desVal);
		} else {
			return true;
		}
	}
}
